home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 22 / CU Amiga Magazine's Super CD-ROM 22 (1998)(EMAP Images)(GB)[!][issue 1998-05].iso / PowerPC / Programming / PPCSmallEiffel / bin_c / pretty6.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-16  |  19.3 KB  |  688 lines
  1. /*
  2. -- ANSI C code generated by :
  3. -- SmallEiffel The GNU Eiffel Compiler -- Release (- 0.82)      --
  4. -- Copyright (C), 1994-98 - LORIA - UHP - CRIN - INRIA - FRANCE --
  5. -- Dominique COLNET and Suzanne COLLIN -    colnet@loria.fr     --
  6. --                 http://www.loria.fr/SmallEiffel              --
  7. */
  8. #include "pretty.h"
  9. /*No:ARRAY[DICTIONARY[RUN_FEATURE,STRING]].clear_all*/
  10. /*No:ARRAY[DICTIONARY[RUN_FEATURE,STRING]].set_all_with*/
  11. void r956make(T956* C,int a1,int a2){
  12. int _needed=0;
  13. C->_lower=a1;
  14. C->_upper=a2;
  15. _needed=((a2)-(a1))+(1);
  16. /*IF*/if ((_needed)>(0)) {
  17. /*IF*/if (((((T956*)C))->_capacity/*4*/)<(_needed)) {
  18. /*IF*/if (((((T956*)C))->_capacity/*4*/)==(0)) {
  19. C->_storage=calloc(_needed,sizeof(T0*));
  20. }
  21. else {
  22. C->_storage=calloc(_needed,sizeof(T0*));
  23. }
  24. /*FI*/C->_capacity=_needed;
  25. }
  26. else {
  27. /*[IRF3.6clear_all*/{T956* C1=C;
  28. T0* __value=NULL;
  29. /*[IRF3.6set_all_with*/{T956* C2=C1;
  30. T0* c1=__value;
  31. r354set_all_with((((T956*)C2))->_storage/*0*/,c1,((((T956*)C2))->_upper/*8*/)-((((T956*)C2))->_lower/*12*/));
  32. }/*]*/
  33. }/*]*/
  34. }
  35. /*FI*/}
  36. /*FI*/}
  37. T0* r956item(T956* C,int a1){
  38. T0* R=NULL;
  39. R=((((T956*)C))->_storage/*0*/)[(a1)-((((T956*)C))->_lower/*12*/)];
  40. return R;
  41. }
  42. void r956resize(T956* C,int a1,int a2){
  43. int _mem=0;
  44. int _up=0;
  45. int _i=0;
  46. T0* _other=NULL;
  47. {T956*n=malloc(sizeof(*n));
  48. *n=M956;
  49. r956make(n,a1,a2);
  50. _other=(T0*)n;
  51. }
  52. _i=r2max((((T956*)C))->_lower/*12*/,(((T956*)((T956*)_other)))->_lower/*12*/);
  53. _up=r2min((((T956*)C))->_upper/*8*/,(((T956*)((T956*)_other)))->_upper/*8*/);
  54. while (!((_i)>(_up))) {
  55. /*[IRF3.6put*/{T956* C1=((T956*)_other);
  56. T0* b1=r956item(C,_i);
  57. int b2=_i;
  58. ((((T956*)C1))->_storage/*0*/)[(b2)-((((T956*)C1))->_lower/*12*/)]=(b1);
  59. }/*]*/
  60. _i=(_i)+(1);
  61. }
  62. *((T956*)(C))=*((T956*)(_other));
  63. }
  64. /*No:ARRAY[DICTIONARY[RUN_FEATURE,STRING]].storage*/
  65. /*No:ARRAY[DICTIONARY[RUN_FEATURE,STRING]].capacity*/
  66. /*No:ARRAY[DICTIONARY[RUN_FEATURE,STRING]].lower*/
  67. /*No:ARRAY[DICTIONARY[RUN_FEATURE,STRING]].put*/
  68. /*No:ARRAY[DICTIONARY[RUN_FEATURE,STRING]].upper*/
  69. int r956count(T956* C){
  70. int R=0;
  71. R=(((((T956*)C))->_upper/*8*/)-((((T956*)C))->_lower/*12*/))+(1);
  72. return R;
  73. }
  74. /*No:ARRAY[INTEGER].clear_all*/
  75. /*No:ARRAY[INTEGER].set_all_with*/
  76. void r429make(T429* C,int a1,int a2){
  77. int _needed=0;
  78. C->_lower=a1;
  79. C->_upper=a2;
  80. _needed=((a2)-(a1))+(1);
  81. /*IF*/if ((_needed)>(0)) {
  82. /*IF*/if (((((T429*)C))->_capacity/*4*/)<(_needed)) {
  83. /*IF*/if (((((T429*)C))->_capacity/*4*/)==(0)) {
  84. C->_storage=calloc(_needed,sizeof(int));
  85. }
  86. else {
  87. C->_storage=calloc(_needed,sizeof(int));
  88. }
  89. /*FI*/C->_capacity=_needed;
  90. }
  91. else {
  92. /*[IRF3.6clear_all*/{T429* C1=C;
  93. int __value=0;
  94. /*[IRF3.6set_all_with*/{T429* C2=C1;
  95. int c1=__value;
  96. r686set_all_with((((T429*)C2))->_storage/*0*/,c1,((((T429*)C2))->_upper/*8*/)-((((T429*)C2))->_lower/*12*/));
  97. }/*]*/
  98. }/*]*/
  99. }
  100. /*FI*/}
  101. /*FI*/}
  102. int r429fast_has(T429* C,int a1){
  103. int R=0;
  104. /*IF*/if ((r429count(C))>(0)) {
  105. R=(r429fast_index_of(C,a1))<=((((T429*)C))->_upper/*8*/);
  106. }
  107. /*FI*/return R;
  108. }
  109. int r429item(T429* C,int a1){
  110. int R=0;
  111. R=((((T429*)C))->_storage/*0*/)[(a1)-((((T429*)C))->_lower/*12*/)];
  112. return R;
  113. }
  114. void r429resize(T429* C,int a1,int a2){
  115. int _mem=0;
  116. int _up=0;
  117. int _i=0;
  118. T0* _other=NULL;
  119. {T429*n=malloc(sizeof(*n));
  120. *n=M429;
  121. r429make(n,a1,a2);
  122. _other=(T0*)n;
  123. }
  124. _i=r2max((((T429*)C))->_lower/*12*/,(((T429*)((T429*)_other)))->_lower/*12*/);
  125. _up=r2min((((T429*)C))->_upper/*8*/,(((T429*)((T429*)_other)))->_upper/*8*/);
  126. while (!((_i)>(_up))) {
  127. /*[IRF3.6put*/{T429* C1=((T429*)_other);
  128. int b1=r429item(C,_i);
  129. int b2=_i;
  130. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  131. }/*]*/
  132. _i=(_i)+(1);
  133. }
  134. *((T429*)(C))=*((T429*)(_other));
  135. }
  136. /*No:ARRAY[INTEGER].storage*/
  137. /*No:ARRAY[INTEGER].capacity*/
  138. /*No:ARRAY[INTEGER].lower*/
  139. int r429fast_index_of(T429* C,int a1){
  140. int R=0;
  141. R=((((T429*)C))->_lower/*12*/)+(r686fast_index_of((((T429*)C))->_storage/*0*/,a1,((((T429*)C))->_upper/*8*/)-((((T429*)C))->_lower/*12*/)));
  142. return R;
  143. }
  144. /*No:ARRAY[INTEGER].put*/
  145. /*No:ARRAY[INTEGER].upper*/
  146. void r429add_last(T429* C,int a1){
  147. int _new_capacity=0;
  148. /*IF*/if (((((T429*)C))->_capacity/*4*/)<((r429count(C))+(1))) {
  149. /*IF*/if (((((T429*)C))->_capacity/*4*/)==(0)) {
  150. C->_capacity=16;
  151. C->_storage=calloc((((T429*)C))->_capacity/*4*/,sizeof(int));
  152. }
  153. else {
  154. _new_capacity=(2)*((((T429*)C))->_capacity/*4*/);
  155. C->_storage=r686realloc((((T429*)C))->_storage/*0*/,(((T429*)C))->_capacity/*4*/,_new_capacity);
  156. C->_capacity=_new_capacity;
  157. }
  158. /*FI*/}
  159. /*FI*/C->_upper=((((T429*)C))->_upper/*8*/)+(1);
  160. /*[IRF3.6put*/{T429* C1=C;
  161. int b1=a1;
  162. int b2=(((T429*)C))->_upper/*8*/;
  163. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  164. }/*]*/
  165. }
  166. int r429count(T429* C){
  167. int R=0;
  168. R=(((((T429*)C))->_upper/*8*/)-((((T429*)C))->_lower/*12*/))+(1);
  169. return R;
  170. }
  171. T0* r764item(T764* C,int a1){
  172. T0* R=NULL;
  173. R=((((T764*)C))->_storage/*0*/)[(a1)-((((T764*)C))->_lower/*12*/)];
  174. return R;
  175. }
  176. /*No:ARRAY[FEATURE_CLAUSE].storage*/
  177. /*No:ARRAY[FEATURE_CLAUSE].capacity*/
  178. /*No:ARRAY[FEATURE_CLAUSE].lower*/
  179. /*No:ARRAY[FEATURE_CLAUSE].put*/
  180. /*No:ARRAY[FEATURE_CLAUSE].upper*/
  181. int r764count(T764* C){
  182. int R=0;
  183. R=(((((T764*)C))->_upper/*8*/)-((((T764*)C))->_lower/*12*/))+(1);
  184. return R;
  185. }
  186. void r764add_last(T764* C,T0* a1){
  187. int _new_capacity=0;
  188. /*IF*/if (((((T764*)C))->_capacity/*4*/)<((r764count(C))+(1))) {
  189. /*IF*/if (((((T764*)C))->_capacity/*4*/)==(0)) {
  190. C->_capacity=16;
  191. C->_storage=calloc((((T764*)C))->_capacity/*4*/,sizeof(T0*));
  192. }
  193. else {
  194. _new_capacity=(2)*((((T764*)C))->_capacity/*4*/);
  195. C->_storage=r42realloc((((T764*)C))->_storage/*0*/,(((T764*)C))->_capacity/*4*/,_new_capacity);
  196. C->_capacity=_new_capacity;
  197. }
  198. /*FI*/}
  199. /*FI*/C->_upper=((((T764*)C))->_upper/*8*/)+(1);
  200. /*[IRF3.6put*/{T764* C1=C;
  201. T0* b1=a1;
  202. int b2=(((T764*)C))->_upper/*8*/;
  203. ((((T764*)C1))->_storage/*0*/)[(b2)-((((T764*)C1))->_lower/*12*/)]=(b1);
  204. }/*]*/
  205. }
  206. /*No:ARRAY[LOCAL_NAME1].clear_all*/
  207. /*No:ARRAY[LOCAL_NAME1].set_all_with*/
  208. void r733make(T733* C,int a1,int a2){
  209. int _needed=0;
  210. C->_lower=a1;
  211. C->_upper=a2;
  212. _needed=((a2)-(a1))+(1);
  213. /*IF*/if ((_needed)>(0)) {
  214. /*IF*/if (((((T733*)C))->_capacity/*8*/)<(_needed)) {
  215. /*IF*/if (((((T733*)C))->_capacity/*8*/)==(0)) {
  216. C->_storage=calloc(_needed,sizeof(T0*));
  217. }
  218. else {
  219. C->_storage=calloc(_needed,sizeof(T0*));
  220. }
  221. /*FI*/C->_capacity=_needed;
  222. }
  223. else {
  224. /*[IRF3.6clear_all*/{T733* C1=C;
  225. T0* __value=NULL;
  226. /*[IRF3.6set_all_with*/{T733* C2=C1;
  227. T0* c1=__value;
  228. r731set_all_with((((T733*)C2))->_storage/*4*/,c1,((((T733*)C2))->_upper/*12*/)-((((T733*)C2))->_lower/*16*/));
  229. }/*]*/
  230. }/*]*/
  231. }
  232. /*FI*/}
  233. /*FI*/}
  234. T0* r733item(T733* C,int a1){
  235. T0* R=NULL;
  236. R=((((T733*)C))->_storage/*4*/)[(a1)-((((T733*)C))->_lower/*16*/)];
  237. return R;
  238. }
  239. /*No:ARRAY[LOCAL_NAME1].storage*/
  240. T0* r733twin(T733* C){
  241. T0* R=NULL;
  242. R=malloc(sizeof(*C));
  243. *((T733*)R)=M733;
  244. r733copy(((T733*)R),((T0*)C));
  245. return R;
  246. }
  247. /*No:ARRAY[LOCAL_NAME1].capacity*/
  248. void r733copy(T733* C,T0* a1){
  249. int _needed_capacity=0;
  250. C->_lower=(((T733*)((T733*)a1)))->_lower/*16*/;
  251. C->_upper=(((T733*)((T733*)a1)))->_upper/*12*/;
  252. _needed_capacity=(((((T733*)C))->_upper/*12*/)-((((T733*)C))->_lower/*16*/))+(1);
  253. /*IF*/if (((((T733*)C))->_capacity/*8*/)<(_needed_capacity)) {
  254. C->_capacity=_needed_capacity;
  255. C->_storage=calloc((((T733*)C))->_capacity/*8*/,sizeof(T0*));
  256. }
  257. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  258. r731copy_from((((T733*)C))->_storage/*4*/,(((T733*)((T733*)a1)))->_storage/*4*/,(_needed_capacity)-(1));
  259. }
  260. /*FI*/}
  261. /*No:ARRAY[LOCAL_NAME1].lower*/
  262. /*No:ARRAY[LOCAL_NAME1].put*/
  263. /*No:ARRAY[LOCAL_NAME1].upper*/
  264. int r733count(T733* C){
  265. int R=0;
  266. R=(((((T733*)C))->_upper/*12*/)-((((T733*)C))->_lower/*16*/))+(1);
  267. return R;
  268. }
  269. void r733add_last(T733* C,T0* a1){
  270. int _new_capacity=0;
  271. /*IF*/if (((((T733*)C))->_capacity/*8*/)<((r733count(C))+(1))) {
  272. /*IF*/if (((((T733*)C))->_capacity/*8*/)==(0)) {
  273. C->_capacity=16;
  274. C->_storage=calloc((((T733*)C))->_capacity/*8*/,sizeof(T0*));
  275. }
  276. else {
  277. _new_capacity=(2)*((((T733*)C))->_capacity/*8*/);
  278. C->_storage=r731realloc((((T733*)C))->_storage/*4*/,(((T733*)C))->_capacity/*8*/,_new_capacity);
  279. C->_capacity=_new_capacity;
  280. }
  281. /*FI*/}
  282. /*FI*/C->_upper=((((T733*)C))->_upper/*12*/)+(1);
  283. /*[IRF3.6put*/{T733* C1=C;
  284. T0* b1=a1;
  285. int b2=(((T733*)C))->_upper/*12*/;
  286. ((((T733*)C1))->_storage/*4*/)[(b2)-((((T733*)C1))->_lower/*16*/)]=(b1);
  287. }/*]*/
  288. }
  289. T0* r733first(T733* C){
  290. T0* R=NULL;
  291. R=r733item(C,(((T733*)C))->_lower/*16*/);
  292. return R;
  293. }
  294. T0* r247item(T247* C,int a1){
  295. T0* R=NULL;
  296. R=((((T247*)C))->_storage/*4*/)[(a1)-((((T247*)C))->_lower/*16*/)];
  297. return R;
  298. }
  299. /*No:ARRAY[WHEN_ITEM_1].storage*/
  300. T0* r247twin(T247* C){
  301. T0* R=NULL;
  302. R=malloc(sizeof(*C));
  303. *((T247*)R)=M247;
  304. r247copy(((T247*)R),((T0*)C));
  305. return R;
  306. }
  307. /*No:ARRAY[WHEN_ITEM_1].capacity*/
  308. void r247copy(T247* C,T0* a1){
  309. int _needed_capacity=0;
  310. C->_lower=(((T247*)((T247*)a1)))->_lower/*16*/;
  311. C->_upper=(((T247*)((T247*)a1)))->_upper/*12*/;
  312. _needed_capacity=(((((T247*)C))->_upper/*12*/)-((((T247*)C))->_lower/*16*/))+(1);
  313. /*IF*/if (((((T247*)C))->_capacity/*8*/)<(_needed_capacity)) {
  314. C->_capacity=_needed_capacity;
  315. C->_storage=calloc((((T247*)C))->_capacity/*8*/,sizeof(T0*));
  316. }
  317. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  318. r497copy_from((((T247*)C))->_storage/*4*/,(((T247*)((T247*)a1)))->_storage/*4*/,(_needed_capacity)-(1));
  319. }
  320. /*FI*/}
  321. /*No:ARRAY[WHEN_ITEM_1].lower*/
  322. /*No:ARRAY[WHEN_ITEM_1].put*/
  323. /*No:ARRAY[WHEN_ITEM_1].upper*/
  324. int r247count(T247* C){
  325. int R=0;
  326. R=(((((T247*)C))->_upper/*12*/)-((((T247*)C))->_lower/*16*/))+(1);
  327. return R;
  328. }
  329. void r247add_last(T247* C,T0* a1){
  330. int _new_capacity=0;
  331. /*IF*/if (((((T247*)C))->_capacity/*8*/)<((r247count(C))+(1))) {
  332. /*IF*/if (((((T247*)C))->_capacity/*8*/)==(0)) {
  333. C->_capacity=16;
  334. C->_storage=calloc((((T247*)C))->_capacity/*8*/,sizeof(T0*));
  335. }
  336. else {
  337. _new_capacity=(2)*((((T247*)C))->_capacity/*8*/);
  338. C->_storage=r497realloc((((T247*)C))->_storage/*4*/,(((T247*)C))->_capacity/*8*/,_new_capacity);
  339. C->_capacity=_new_capacity;
  340. }
  341. /*FI*/}
  342. /*FI*/C->_upper=((((T247*)C))->_upper/*12*/)+(1);
  343. /*[IRF3.6put*/{T247* C1=C;
  344. T0* b1=a1;
  345. int b2=(((T247*)C))->_upper/*12*/;
  346. ((((T247*)C1))->_storage/*4*/)[(b2)-((((T247*)C1))->_lower/*16*/)]=(b1);
  347. }/*]*/
  348. }
  349. T0* r948item(T948* C,int a1){
  350. T0* R=NULL;
  351. R=((((T948*)C))->_storage/*0*/)[(a1)-((((T948*)C))->_lower/*12*/)];
  352. return R;
  353. }
  354. /*No:ARRAY[IFTHEN].storage*/
  355. T0* r948twin(T948* C){
  356. T0* R=NULL;
  357. R=malloc(sizeof(*C));
  358. *((T948*)R)=M948;
  359. r948copy(((T948*)R),((T0*)C));
  360. return R;
  361. }
  362. /*No:ARRAY[IFTHEN].capacity*/
  363. void r948copy(T948* C,T0* a1){
  364. int _needed_capacity=0;
  365. C->_lower=(((T948*)((T948*)a1)))->_lower/*12*/;
  366. C->_upper=(((T948*)((T948*)a1)))->_upper/*8*/;
  367. _needed_capacity=(((((T948*)C))->_upper/*8*/)-((((T948*)C))->_lower/*12*/))+(1);
  368. /*IF*/if (((((T948*)C))->_capacity/*4*/)<(_needed_capacity)) {
  369. C->_capacity=_needed_capacity;
  370. C->_storage=calloc((((T948*)C))->_capacity/*4*/,sizeof(T0*));
  371. }
  372. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  373. r191copy_from((((T948*)C))->_storage/*0*/,(((T948*)((T948*)a1)))->_storage/*0*/,(_needed_capacity)-(1));
  374. }
  375. /*FI*/}
  376. /*No:ARRAY[IFTHEN].lower*/
  377. /*No:ARRAY[IFTHEN].put*/
  378. /*No:ARRAY[IFTHEN].upper*/
  379. int r948count(T948* C){
  380. int R=0;
  381. R=(((((T948*)C))->_upper/*8*/)-((((T948*)C))->_lower/*12*/))+(1);
  382. return R;
  383. }
  384. void r948add_last(T948* C,T0* a1){
  385. int _new_capacity=0;
  386. /*IF*/if (((((T948*)C))->_capacity/*4*/)<((r948count(C))+(1))) {
  387. /*IF*/if (((((T948*)C))->_capacity/*4*/)==(0)) {
  388. C->_capacity=16;
  389. C->_storage=calloc((((T948*)C))->_capacity/*4*/,sizeof(T0*));
  390. }
  391. else {
  392. _new_capacity=(2)*((((T948*)C))->_capacity/*4*/);
  393. C->_storage=r191realloc((((T948*)C))->_storage/*0*/,(((T948*)C))->_capacity/*4*/,_new_capacity);
  394. C->_capacity=_new_capacity;
  395. }
  396. /*FI*/}
  397. /*FI*/C->_upper=((((T948*)C))->_upper/*8*/)+(1);
  398. /*[IRF3.6put*/{T948* C1=C;
  399. T0* b1=a1;
  400. int b2=(((T948*)C))->_upper/*8*/;
  401. ((((T948*)C1))->_storage/*0*/)[(b2)-((((T948*)C1))->_lower/*12*/)]=(b1);
  402. }/*]*/
  403. }
  404. /*No:ARRAY[ARGUMENT_NAME1].clear_all*/
  405. /*No:ARRAY[ARGUMENT_NAME1].set_all_with*/
  406. void r65make(T65* C,int a1,int a2){
  407. int _needed=0;
  408. C->_lower=a1;
  409. C->_upper=a2;
  410. _needed=((a2)-(a1))+(1);
  411. /*IF*/if ((_needed)>(0)) {
  412. /*IF*/if (((((T65*)C))->_capacity/*8*/)<(_needed)) {
  413. /*IF*/if (((((T65*)C))->_capacity/*8*/)==(0)) {
  414. C->_storage=calloc(_needed,sizeof(T0*));
  415. }
  416. else {
  417. C->_storage=calloc(_needed,sizeof(T0*));
  418. }
  419. /*FI*/C->_capacity=_needed;
  420. }
  421. else {
  422. /*[IRF3.6clear_all*/{T65* C1=C;
  423. T0* __value=NULL;
  424. /*[IRF3.6set_all_with*/{T65* C2=C1;
  425. T0* c1=__value;
  426. r24set_all_with((((T65*)C2))->_storage/*4*/,c1,((((T65*)C2))->_upper/*12*/)-((((T65*)C2))->_lower/*16*/));
  427. }/*]*/
  428. }/*]*/
  429. }
  430. /*FI*/}
  431. /*FI*/}
  432. T0* r65item(T65* C,int a1){
  433. T0* R=NULL;
  434. R=((((T65*)C))->_storage/*4*/)[(a1)-((((T65*)C))->_lower/*16*/)];
  435. return R;
  436. }
  437. /*No:ARRAY[ARGUMENT_NAME1].storage*/
  438. T0* r65twin(T65* C){
  439. T0* R=NULL;
  440. R=malloc(sizeof(*C));
  441. *((T65*)R)=M65;
  442. r65copy(((T65*)R),((T0*)C));
  443. return R;
  444. }
  445. /*No:ARRAY[ARGUMENT_NAME1].capacity*/
  446. void r65copy(T65* C,T0* a1){
  447. int _needed_capacity=0;
  448. C->_lower=(((T65*)((T65*)a1)))->_lower/*16*/;
  449. C->_upper=(((T65*)((T65*)a1)))->_upper/*12*/;
  450. _needed_capacity=(((((T65*)C))->_upper/*12*/)-((((T65*)C))->_lower/*16*/))+(1);
  451. /*IF*/if (((((T65*)C))->_capacity/*8*/)<(_needed_capacity)) {
  452. C->_capacity=_needed_capacity;
  453. C->_storage=calloc((((T65*)C))->_capacity/*8*/,sizeof(T0*));
  454. }
  455. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  456. r24copy_from((((T65*)C))->_storage/*4*/,(((T65*)((T65*)a1)))->_storage/*4*/,(_needed_capacity)-(1));
  457. }
  458. /*FI*/}
  459. /*No:ARRAY[ARGUMENT_NAME1].lower*/
  460. /*No:ARRAY[ARGUMENT_NAME1].put*/
  461. /*No:ARRAY[ARGUMENT_NAME1].upper*/
  462. int r65count(T65* C){
  463. int R=0;
  464. R=(((((T65*)C))->_upper/*12*/)-((((T65*)C))->_lower/*16*/))+(1);
  465. return R;
  466. }
  467. void r65add_last(T65* C,T0* a1){
  468. int _new_capacity=0;
  469. /*IF*/if (((((T65*)C))->_capacity/*8*/)<((r65count(C))+(1))) {
  470. /*IF*/if (((((T65*)C))->_capacity/*8*/)==(0)) {
  471. C->_capacity=16;
  472. C->_storage=calloc((((T65*)C))->_capacity/*8*/,sizeof(T0*));
  473. }
  474. else {
  475. _new_capacity=(2)*((((T65*)C))->_capacity/*8*/);
  476. C->_storage=r24realloc((((T65*)C))->_storage/*4*/,(((T65*)C))->_capacity/*8*/,_new_capacity);
  477. C->_capacity=_new_capacity;
  478. }
  479. /*FI*/}
  480. /*FI*/C->_upper=((((T65*)C))->_upper/*12*/)+(1);
  481. /*[IRF3.6put*/{T65* C1=C;
  482. T0* b1=a1;
  483. int b2=(((T65*)C))->_upper/*12*/;
  484. ((((T65*)C1))->_storage/*4*/)[(b2)-((((T65*)C1))->_lower/*16*/)]=(b1);
  485. }/*]*/
  486. }
  487. T0* r65first(T65* C){
  488. T0* R=NULL;
  489. R=r65item(C,(((T65*)C))->_lower/*16*/);
  490. return R;
  491. }
  492. /*No:ARRAY[E_FEATURE].clear_all*/
  493. /*No:ARRAY[E_FEATURE].set_all_with*/
  494. void r495make(T495* C,int a1,int a2){
  495. int _needed=0;
  496. C->_lower=a1;
  497. C->_upper=a2;
  498. _needed=((a2)-(a1))+(1);
  499. /*IF*/if ((_needed)>(0)) {
  500. /*IF*/if (((((T495*)C))->_capacity/*4*/)<(_needed)) {
  501. /*IF*/if (((((T495*)C))->_capacity/*4*/)==(0)) {
  502. C->_storage=calloc(_needed,sizeof(T0*));
  503. }
  504. else {
  505. C->_storage=calloc(_needed,sizeof(T0*));
  506. }
  507. /*FI*/C->_capacity=_needed;
  508. }
  509. else {
  510. /*[IRF3.6clear_all*/{T495* C1=C;
  511. T0* __value=NULL;
  512. /*[IRF3.6set_all_with*/{T495* C2=C1;
  513. T0* c1=__value;
  514. r822set_all_with((((T495*)C2))->_storage/*0*/,c1,((((T495*)C2))->_upper/*8*/)-((((T495*)C2))->_lower/*12*/));
  515. }/*]*/
  516. }/*]*/
  517. }
  518. /*FI*/}
  519. /*FI*/}
  520. T0* r495item(T495* C,int a1){
  521. T0* R=NULL;
  522. R=((((T495*)C))->_storage/*0*/)[(a1)-((((T495*)C))->_lower/*12*/)];
  523. return R;
  524. }
  525. void r495resize(T495* C,int a1,int a2){
  526. int _mem=0;
  527. int _up=0;
  528. int _i=0;
  529. T0* _other=NULL;
  530. {T495*n=malloc(sizeof(*n));
  531. *n=M495;
  532. r495make(n,a1,a2);
  533. _other=(T0*)n;
  534. }
  535. _i=r2max((((T495*)C))->_lower/*12*/,(((T495*)((T495*)_other)))->_lower/*12*/);
  536. _up=r2min((((T495*)C))->_upper/*8*/,(((T495*)((T495*)_other)))->_upper/*8*/);
  537. while (!((_i)>(_up))) {
  538. /*[IRF3.6put*/{T495* C1=((T495*)_other);
  539. T0* b1=r495item(C,_i);
  540. int b2=_i;
  541. ((((T495*)C1))->_storage/*0*/)[(b2)-((((T495*)C1))->_lower/*12*/)]=(b1);
  542. }/*]*/
  543. _i=(_i)+(1);
  544. }
  545. *((T495*)(C))=*((T495*)(_other));
  546. }
  547. /*No:ARRAY[E_FEATURE].storage*/
  548. /*No:ARRAY[E_FEATURE].capacity*/
  549. /*No:ARRAY[E_FEATURE].lower*/
  550. /*No:ARRAY[E_FEATURE].put*/
  551. /*No:ARRAY[E_FEATURE].upper*/
  552. void r495add_last(T495* C,T0* a1){
  553. int _new_capacity=0;
  554. /*IF*/if (((((T495*)C))->_capacity/*4*/)<((r495count(C))+(1))) {
  555. /*IF*/if (((((T495*)C))->_capacity/*4*/)==(0)) {
  556. C->_capacity=16;
  557. C->_storage=calloc((((T495*)C))->_capacity/*4*/,sizeof(T0*));
  558. }
  559. else {
  560. _new_capacity=(2)*((((T495*)C))->_capacity/*4*/);
  561. C->_storage=r822realloc((((T495*)C))->_storage/*0*/,(((T495*)C))->_capacity/*4*/,_new_capacity);
  562. C->_capacity=_new_capacity;
  563. }
  564. /*FI*/}
  565. /*FI*/C->_upper=((((T495*)C))->_upper/*8*/)+(1);
  566. /*[IRF3.6put*/{T495* C1=C;
  567. T0* b1=a1;
  568. int b2=(((T495*)C))->_upper/*8*/;
  569. ((((T495*)C1))->_storage/*0*/)[(b2)-((((T495*)C1))->_lower/*12*/)]=(b1);
  570. }/*]*/
  571. }
  572. int r495count(T495* C){
  573. int R=0;
  574. R=(((((T495*)C))->_upper/*8*/)-((((T495*)C))->_lower/*12*/))+(1);
  575. return R;
  576. }
  577. T0* r263item(T263* C,int a1){
  578. T0* R=NULL;
  579. R=((((T263*)C))->_storage/*4*/)[(a1)-((((T263*)C))->_lower/*16*/)];
  580. return R;
  581. }
  582. /*No:ARRAY[WHEN_ITEM_2].storage*/
  583. T0* r263twin(T263* C){
  584. T0* R=NULL;
  585. R=malloc(sizeof(*C));
  586. *((T263*)R)=M263;
  587. r263copy(((T263*)R),((T0*)C));
  588. return R;
  589. }
  590. /*No:ARRAY[WHEN_ITEM_2].capacity*/
  591. void r263copy(T263* C,T0* a1){
  592. int _needed_capacity=0;
  593. C->_lower=(((T263*)((T263*)a1)))->_lower/*16*/;
  594. C->_upper=(((T263*)((T263*)a1)))->_upper/*12*/;
  595. _needed_capacity=(((((T263*)C))->_upper/*12*/)-((((T263*)C))->_lower/*16*/))+(1);
  596. /*IF*/if (((((T263*)C))->_capacity/*8*/)<(_needed_capacity)) {
  597. C->_capacity=_needed_capacity;
  598. C->_storage=calloc((((T263*)C))->_capacity/*8*/,sizeof(T0*));
  599. }
  600. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  601. r533copy_from((((T263*)C))->_storage/*4*/,(((T263*)((T263*)a1)))->_storage/*4*/,(_needed_capacity)-(1));
  602. }
  603. /*FI*/}
  604. /*No:ARRAY[WHEN_ITEM_2].lower*/
  605. /*No:ARRAY[WHEN_ITEM_2].put*/
  606. /*No:ARRAY[WHEN_ITEM_2].upper*/
  607. int r263count(T263* C){
  608. int R=0;
  609. R=(((((T263*)C))->_upper/*12*/)-((((T263*)C))->_lower/*16*/))+(1);
  610. return R;
  611. }
  612. void r263add_last(T263* C,T0* a1){
  613. int _new_capacity=0;
  614. /*IF*/if (((((T263*)C))->_capacity/*8*/)<((r263count(C))+(1))) {
  615. /*IF*/if (((((T263*)C))->_capacity/*8*/)==(0)) {
  616. C->_capacity=16;
  617. C->_storage=calloc((((T263*)C))->_capacity/*8*/,sizeof(T0*));
  618. }
  619. else {
  620. _new_capacity=(2)*((((T263*)C))->_capacity/*8*/);
  621. C->_storage=r533realloc((((T263*)C))->_storage/*4*/,(((T263*)C))->_capacity/*8*/,_new_capacity);
  622. C->_capacity=_new_capacity;
  623. }
  624. /*FI*/}
  625. /*FI*/C->_upper=((((T263*)C))->_upper/*12*/)+(1);
  626. /*[IRF3.6put*/{T263* C1=C;
  627. T0* b1=a1;
  628. int b2=(((T263*)C))->_upper/*12*/;
  629. ((((T263*)C1))->_storage/*4*/)[(b2)-((((T263*)C1))->_lower/*16*/)]=(b1);
  630. }/*]*/
  631. }
  632. T0* r701item(T701* C,int a1){
  633. T0* R=NULL;
  634. R=((((T701*)C))->_storage/*0*/)[(a1)-((((T701*)C))->_lower/*12*/)];
  635. return R;
  636. }
  637. /*No:ARRAY[TYPE].storage*/
  638. T0* r701twin(T701* C){
  639. T0* R=NULL;
  640. R=malloc(sizeof(*C));
  641. *((T701*)R)=M701;
  642. r701copy(((T701*)R),((T0*)C));
  643. return R;
  644. }
  645. /*No:ARRAY[TYPE].capacity*/
  646. void r701copy(T701* C,T0* a1){
  647. int _needed_capacity=0;
  648. C->_lower=(((T701*)((T701*)a1)))->_lower/*12*/;
  649. C->_upper=(((T701*)((T701*)a1)))->_upper/*8*/;
  650. _needed_capacity=(((((T701*)C))->_upper/*8*/)-((((T701*)C))->_lower/*12*/))+(1);
  651. /*IF*/if (((((T701*)C))->_capacity/*4*/)<(_needed_capacity)) {
  652. C->_capacity=_needed_capacity;
  653. C->_storage=calloc((((T701*)C))->_capacity/*4*/,sizeof(T0*));
  654. }
  655. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  656. r770copy_from((((T701*)C))->_storage/*0*/,(((T701*)((T701*)a1)))->_storage/*0*/,(_needed_capacity)-(1));
  657. }
  658. /*FI*/}
  659. /*No:ARRAY[TYPE].lower*/
  660. /*No:ARRAY[TYPE].put*/
  661. /*No:ARRAY[TYPE].upper*/
  662. int r701count(T701* C){
  663. int R=0;
  664. R=(((((T701*)C))->_upper/*8*/)-((((T701*)C))->_lower/*12*/))+(1);
  665. return R;
  666. }
  667. void r701add_last(T701* C,T0* a1){
  668. int _new_capacity=0;
  669. /*IF*/if (((((T701*)C))->_capacity/*4*/)<((r701count(C))+(1))) {
  670. /*IF*/if (((((T701*)C))->_capacity/*4*/)==(0)) {
  671. C->_capacity=16;
  672. C->_storage=calloc((((T701*)C))->_capacity/*4*/,sizeof(T0*));
  673. }
  674. else {
  675. _new_capacity=(2)*((((T701*)C))->_capacity/*4*/);
  676. C->_storage=r770realloc((((T701*)C))->_storage/*0*/,(((T701*)C))->_capacity/*4*/,_new_capacity);
  677. C->_capacity=_new_capacity;
  678. }
  679. /*FI*/}
  680. /*FI*/C->_upper=((((T701*)C))->_upper/*8*/)+(1);
  681. /*[IRF3.6put*/{T701* C1=C;
  682. T0* b1=a1;
  683. int b2=(((T701*)C))->_upper/*8*/;
  684. ((((T701*)C1))->_storage/*0*/)[(b2)-((((T701*)C1))->_lower/*12*/)]=(b1);
  685. }/*]*/
  686. }
  687.  
  688.